// @eslint-no-unused-vars 此文件禁用
const { spawn } = require('node:child_process');
const fs = require('node:fs');
const os = require('node:os');
const { resolve } = require('node:path');
// 新增依赖项 - 用于美化界面
const figlet = require('figlet');
/**
 * 代替 package.json 中的 scripts 启动配置
 * @description 该脚本用于启动项目 包括功能项(预览|运行|打包)
 */
const inquirer = require('inquirer');
const colors = require('picocolors');

// 读取.env文件中的变量
const loadEnvVars = (envPath) => {
  try {
    if (!fs.existsSync(envPath)) { return {}; }

    const content = fs.readFileSync(envPath, 'utf8');
    const envVars = {};

    content.split('\n').forEach((line) => {
      // 忽略注释和空行
      if (line.trim().startsWith('#') || !line.trim()) { return; }

      // 处理形如 KEY=VALUE 的环境变量定义
      const match = line.match(/^\s*([\w.-]+)\s*=\s*(.*)?\s*$/);
      if (match) {
        const key = match[1];
        let value = match[2] || '';

        // 移除包裹值的引号
        if (value.startsWith('"') && value.endsWith('"')) {
          value = value.slice(1, -1);
        }
        else if (value.startsWith('\'') && value.endsWith('\'')) {
          value = value.slice(1, -1);
        }

        envVars[key] = value;
      }
    });

    return envVars;
  }
  catch (error) {
    console.error(`读取环境变量文件失败: ${error.message}`);
    return {};
  }
};
// 加载基础环境变量
const baseEnvPath = resolve(__dirname, '../env/.env');
const baseEnvVars = loadEnvVars(baseEnvPath);
// 应用标题
const globTitle = baseEnvVars.VITE_GLOB_APP_TITLE || 'vite-vue3';
// 从环境变量获取其他配置 打包内存上限默认 8G
const memoryLimit = Number.parseInt(baseEnvVars.VITE_BUILD_MEMORY_LIMIT) || 8 * 1024;
const defaultPort = Number.parseInt(baseEnvVars.VITE_DEV_PORT) || 80;
// 是否默认打开浏览器
const openBrowser = baseEnvVars.VITE_DEV_OPEN_BROWSER === 'true';
// 开发服务时是否同时启动文档服务
const startDocs = baseEnvVars.VITE_DEV_START_DOCS === 'true';
// 颜色支持级别（0=禁用，1=16色，2=256色，3=16百万色）
const forceColorLevel = Number.parseInt(baseEnvVars.VITE_FORCE_COLOR) || 3;
// 检测是否为交互式终端
const isInteractiveTerminal = process.stdout.isTTY;
// 构建时是否显示警告
const showBuildWarnings = baseEnvVars.VITE_BUILD_SHOW_WARNINGS === 'true';
// 构建完成后是否自动打开产物目录
const openOutDir = baseEnvVars.VITE_BUILD_OPEN_OUTDIR === 'true';
// 打包输出目录
const buildOutputDir = baseEnvVars.VITE_BUILD_OUTPUT_DIR || '.outDir/dist';
// 是否启用debug模式
const enableDebugMode = baseEnvVars.VITE_BUILD_DEBUG_MODE === 'true';

// 检测操作系统
const isWindows = os.platform() === 'win32';
const isMac = os.platform() === 'darwin';
const isLinux = os.platform() === 'linux';

// 系统信息
const sysInfo = {
  platform: os.platform(),
  release: os.release(),
  arch: os.arch(),
  cpus: os.cpus().length,
  memory: `${Math.round(os.totalmem() / (1024 * 1024 * 1024))}GB`,
  hostname: os.hostname(),
  username: os.userInfo().username,
};

// 资源监控函数
// 资源监控函数
const monitorResources = (childProcess, options = {}) => {
  const { interval = 3000, threshold = 80 } = options;
  let hasWarned = false;
  const tableId = null; // 表格ID，用于标识和更新

  if (!childProcess) { return null; }

  // 检测终端是否支持Unicode
  const supportsUnicode = () => {
    return (
      process.platform === 'darwin'
      || process.env.TERM_PROGRAM === 'iTerm.app'
      || process.env.WT_SESSION !== undefined // Windows Terminal
      || process.env.ConEmuTask !== undefined // ConEmu
      || (process.platform === 'win32' && Number.parseInt(process.env.TERM_PROGRAM_VERSION || '0') >= 7)
    ); // PowerShell 7+
  };

  // 根据终端决定使用Unicode还是ASCII表格字符
  const tableChars = supportsUnicode()
    ? { tl: '┌', tr: '┐', bl: '└', br: '┘', h: '─', v: '│', hm: '┬', vm: '┼', lm: '├', rm: '┤' }
    : { tl: '+', tr: '+', bl: '+', br: '+', h: '-', v: '|', hm: '+', vm: '+', lm: '+', rm: '+' };

  // 创建表格样式的状态信息
  const createTableInfo = (memUsed, memHeap, memFree, memTotal, cpuUsage) => {
    const h10 = tableChars.h.repeat(10);
    const h11 = tableChars.h.repeat(11);

    // 格式化显示，右对齐数值
    const formatMB = val => `${String(val).padStart(6)} MB`;
    const formatGB = val => String(val).padStart(2);
    const formatCPU = val => `${String(val).padStart(6)} %`;

    return (
      `${tableChars.tl}${h10}${tableChars.hm}${h10}${tableChars.hm}${h11}${tableChars.hm}${h10}${tableChars.tr}\n`
      + `${tableChars.v} 内存使用 ${tableChars.v} 堆内存   ${tableChars.v} 可用/总计 ${tableChars.v} CPU使用  ${tableChars.v}\n`
      + `${tableChars.lm}${h10}${tableChars.vm}${h10}${tableChars.vm}${h11}${tableChars.vm}${h10}${tableChars.rm}\n`
      + `${tableChars.v} ${formatMB(memUsed)} ${tableChars.v} ${formatMB(memHeap)} ${tableChars.v} ${formatGB(memFree)}/${formatGB(memTotal)} GB  ${tableChars.v} ${formatCPU(cpuUsage)} ${tableChars.v}\n`
      + `${tableChars.bl}${h10}${tableChars.hm}${h10}${tableChars.hm}${h11}${tableChars.hm}${h10}${tableChars.br}`
    );
  };

  // 清除从光标到行尾的字符
  const clearLine = () => {
    process.stdout.write('\r\x1B[K');
  };

  // 在控制台创建一个专用区域用于显示表格
  console.log(colors.cyan('【系统资源监控】- 实时更新中...'));

  // 初始化表格（使用占位符值）
  const initialTable = createTableInfo('--', '--', '--', '--', '--');
  console.log(colors.cyan(initialTable));

  // 存储表格行数（用于计算上移光标的距离）
  const tableLines = initialTable.split('\n').length;

  // 定义更新表格的函数
  const updateTable = (memUsed, memHeap, memFree, memTotal, cpuUsage) => {
    // 将光标上移到表格开始位置（表格行数+标题行）
    process.stdout.write(`\x1B[${tableLines + 1}A`);

    // 清除并重写标题行
    clearLine();
    process.stdout.write(`\r${colors.cyan('【系统资源监控】- 实时更新中...')}`);

    // 逐行清除并重写表格
    const tableContent = createTableInfo(memUsed, memHeap, memFree, memTotal, cpuUsage);
    const tableRows = tableContent.split('\n');

    for (let i = 0; i < tableRows.length; i++) {
      process.stdout.write('\n'); // 移到下一行
      clearLine(); // 清除该行
      process.stdout.write(`\r${colors.cyan(tableRows[i])}`); // 重写该行
    }

    // 将光标移回表格下方
    process.stdout.write('\n');
  };

  const monitor = setInterval(() => {
    try {
      // 获取当前进程内存使用情况
      const memUsage = process.memoryUsage();
      const usedMemoryMB = Math.round(memUsage.rss / 1024 / 1024);
      const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
      const totalMemoryGB = Math.round(os.totalmem() / 1024 / 1024 / 1024);
      const freeMemoryGB = Math.round(os.freemem() / 1024 / 1024 / 1024);

      // 获取CPU使用情况
      const cpus = os.cpus();
      const cpuUsage = cpus.map((cpu) => {
        const total = Object.values(cpu.times).reduce((acc, tv) => acc + tv, 0);
        const idle = cpu.times.idle;
        return 100 - (idle / total) * 100;
      });
      const avgCpuUsage = Math.round(cpuUsage.reduce((acc, usage) => acc + usage, 0) / cpus.length);

      // 更新表格内容
      updateTable(usedMemoryMB, heapUsedMB, freeMemoryGB, totalMemoryGB, avgCpuUsage);

      // 内存使用过高警告
      if (usedMemoryMB > memoryLimit * 0.8 && !hasWarned) {
        logger.warning(`内存使用量过高: ${usedMemoryMB}MB，接近配置的${memoryLimit}MB限制`);
        hasWarned = true;
      }

      // CPU使用过高警告
      if (avgCpuUsage > threshold) {
        logger.warning(`CPU使用率较高: ${avgCpuUsage}%，可能会影响系统性能`);
      }
    }
    catch (err) {
      logger.debug(`资源监控出错: ${err.message}`);
    }
  }, interval);

  // 返回用于清理的函数
  return () => {
    clearInterval(monitor);
    logger.info('资源监控已停止');
  };
};

// 日志输出相关函数
const logger = {
  info: message => console.log(colors.cyan(`[ ℹ️ INFO ] ${message}`)),
  success: message => console.log(colors.green(`[ ✅ SUCCESS ] ${message}`)),
  warning: message => console.log(colors.yellow(`[ ⚠️ WARNING ] ${message}`)),
  error: message => console.log(colors.red(`[ ❌ ERROR ] ${message}`)),
  title: message => console.log(colors.magenta(`\n───── ${message} ─────\n`)),
  divider: () => console.log(colors.dim('╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌')),
  json: data => console.log(colors.gray(JSON.stringify(data, null, 2))),
  debug: message => process.env.DEBUG && console.log(colors.gray(`[ 🔍 DEBUG ] ${message}`)),
  system: () => {
    console.log(colors.blue(`[ 🖥️  系统信息 ]`));
    console.log(
      colors.blue(
        `├─ 操作系统: ${isWindows ? 'Windows' : isMac ? 'macOS' : 'Linux'} (${sysInfo.platform} ${sysInfo.release})`,
      ),
    );
    console.log(colors.blue(`├─ 架构: ${sysInfo.arch}`));
    console.log(colors.blue(`├─ CPU核心: ${sysInfo.cpus}`));
    console.log(colors.blue(`├─ 内存: ${sysInfo.memory}`));
    console.log(colors.blue(`└─ 用户: ${sysInfo.username}@${sysInfo.hostname}`));
  },
};

// 美化界面标题
const printAppTitle = () => {
  try {
    const title = figlet.textSync(globTitle, {
      font: 'Standard',
      horizontalLayout: 'default',
      verticalLayout: 'default',
    });
    console.log(colors.magenta(title));
  }
  catch (e) {
    // 如果figlet失败，使用简单的标题
    console.log(colors.magenta(`\n${'='.repeat(20)} ${globTitle} ${'='.repeat(20)}\n`));
  }
  console.log(colors.cyan(`${'='.repeat(50)}`));
  console.log(colors.green(`      ${globTitle}`));
  console.log(colors.cyan(`${'='.repeat(50)}\n`));
};

// 创建简易的spinner实现，而不是使用ora库
const createSpinner = (text, options = {}) => {
  // 默认使用旋转动画，除非明确指定使用进度条
  const useProgressBar = options.useProgressBar === true;

  // 旋转动画相关设置
  const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
  let frameIndex = 0;

  // 进度条相关设置
  const progressBarWidth = 20; // 进度条长度
  const progressChars = {
    complete: '█', // 完成部分
    incomplete: '░', // 未完成部分
    head: '', // 进度条前沿
  };

  let interval = null;
  const enabled = true;
  let currentText = text || '';
  let progress = 0; // 当前进度(0-100)
  let isIndeterminate = true; // 是否为不确定进度

  // 颜色映射
  const stateColors = {
    normal: colors.cyan, // 默认蓝色
    success: colors.green, // 成功绿色
    error: colors.red, // 错误红色
    warning: colors.yellow, // 警告黄色
    info: colors.blue, // 信息蓝色
  };

  let currentColor = stateColors.normal;

  // 渲染旋转动画
  const renderSpinner = () => {
    const frame = spinnerFrames[frameIndex];
    frameIndex = (frameIndex + 1) % spinnerFrames.length;
    return frame;
  };

  // 渲染进度条
  const renderBar = () => {
    if (isIndeterminate) {
      // 不确定进度，显示动态进度条
      const animWidth = Math.floor(progressBarWidth * 0.3); // 动画块宽度
      const pos = Math.floor((Date.now() / 100) % (progressBarWidth - animWidth));

      let bar = '';
      for (let i = 0; i < progressBarWidth; i++) {
        if (i >= pos && i < pos + animWidth) {
          bar += progressChars.complete;
        }
        else {
          bar += progressChars.incomplete;
        }
      }
      return bar;
    }
    else {
      // 确定进度，显示固定进度条
      const completed = Math.floor(progressBarWidth * (progress / 100));

      let bar = '';
      for (let i = 0; i < progressBarWidth; i++) {
        if (i < completed) {
          bar += progressChars.complete;
        }
        else {
          bar += progressChars.incomplete;
        }
      }
      return bar;
    }
  };

  const spinner = {
    useProgressBar,
    start: () => {
      if (interval) { return spinner; }
      const updateDisplay = () => {
        if (!enabled) { return; }

        if (useProgressBar) {
          // 使用进度条样式
          const bar = renderBar();
          const displayText = isIndeterminate ? currentText : `${currentText} (${progress}%)`;
          process.stdout.write(`\r${currentColor(`[${bar}]`)} ${displayText}`);
        }
        else {
          // 使用旋转动画样式
          const frame = renderSpinner();
          process.stdout.write(`\r${currentColor(frame)} ${currentText}`);
        }
      };
      interval = setInterval(updateDisplay, useProgressBar ? 100 : 80);
      updateDisplay();
      return spinner;
    },
    stop: () => {
      if (interval) {
        clearInterval(interval);
        interval = null;
        process.stdout.write('\r\x1B[K'); // 清除当前行
      }
      return spinner;
    },
    succeed: (msg) => {
      spinner.stop();
      const icon = '✓';
      console.log(`${colors.green(icon)} ${msg || currentText}`);
      return spinner;
    },
    fail: (msg) => {
      spinner.stop();
      const icon = '✗';
      console.log(`${colors.red(icon)} ${msg || currentText}`);
      return spinner;
    },
    info: (msg) => {
      spinner.stop();
      const icon = 'ℹ';
      console.log(`${colors.blue(icon)} ${msg || currentText}`);
      return spinner;
    },
    warn: (msg) => {
      spinner.stop();
      const icon = '⚠';
      console.log(`${colors.yellow(icon)} ${msg || currentText}`);
      return spinner;
    },
    // @eslint-disable-next-line no-unused-vars
    text: (newText) => {
      currentText = newText;
      // 尝试提取百分比信息 (仅在使用进度条时)
      if (useProgressBar) {
        const percentMatch = newText.match(/(\d+(?:\.\d+)?)%/);
        if (percentMatch && percentMatch[1]) {
          progress = Number.parseFloat(percentMatch[1]);
          isIndeterminate = false;
        }
        else {
          isIndeterminate = true;
        }
      }
      return spinner;
    },
    // 设置进度百分比(0-100) - 仅在使用进度条时有效
    setProgress: (value) => {
      if (useProgressBar) {
        progress = Math.max(0, Math.min(100, value));
        isIndeterminate = false;
      }
      return spinner;
    },
    // 设置颜色状态
    setState: (state) => {
      currentColor = stateColors[state] || stateColors.normal;
      return spinner;
    },
  };

  return spinner;
};

// 用于存储历史选择
const HISTORY_FILE = resolve(__dirname, '.script-history.json');

// 读取历史选择记录
const readHistory = () => {
  try {
    if (fs.existsSync(HISTORY_FILE)) {
      return JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf8'));
    }
  }
  catch (err) {
    logger.debug(`读取历史记录出错: ${err.message}`);
  }
  return {};
};

// 保存历史选择
const saveHistory = (data) => {
  try {
    fs.writeFileSync(HISTORY_FILE, JSON.stringify(data, null, 2));
  }
  catch (err) {
    logger.debug(`保存历史记录出错: ${err.message}`);
  }
};

// 适配不同操作系统的路径
const normalizePath = (path) => {
  if (!path) { return path; }
  // 处理不同系统的路径分隔符
  const normalized = isWindows ? path.replace(/\//g, '\\') : path;
  // 处理相对路径
  if (normalized.startsWith('./') || normalized.startsWith('.\\')) {
    return normalized; // 保留相对路径标记
  }
  return normalized;
};

// 检查系统兼容性
const checkSystemCompatibility = () => {
  const issues = [];

  // 检查Node版本
  const nodeVersion = process.versions.node.split('.').map(Number);
  if (nodeVersion[0] < 20) {
    issues.push(`Node.js版本过低 (${process.versions.node})，建议升级至>=v20.18.1或更高版本`);
  }

  // 检查平台特定问题
  if (isWindows) {
    // Windows特定检查
    if (process.env.PATH.length > 2048) {
      issues.push('Windows PATH环境变量过长，可能导致命令执行问题');
    }
  }
  else if (isLinux) {
    // Linux特定检查
    try {
      const hasUnzip
        = require('node:child_process').execSync('which unzip').toString().trim().length > 0;
      if (!hasUnzip) {
        issues.push('未检测到unzip工具，这可能影响部署时的解压操作');
      }
    }
    catch (e) {
      issues.push('未检测到unzip工具，这可能影响部署时的解压操作');
    }
  }

  return issues;
};

// 获取Vite路径，适配不同操作系统
const getVitePath = () => {
  const relativePath = './node_modules/vite/bin/vite.js';
  return normalizePath(relativePath);
};

// 动态获取 modes
const envDir = resolve(__dirname, './../env');
logger.info(`正在加载环境配置文件，目录: ${envDir}`);

const modes = fs
  .readdirSync(envDir) // 读取 env 目录下的文件
  .filter(
    file =>
      file.startsWith('.env.')
      && !file.startsWith('.env.static_')
      && !file.startsWith('.env.config'),
  ) // 过滤出 .env 文件
  .map(file => file.replace('.env.', '')); // 提取模式名

if (modes.length === 0) {
  logger.error('未找到有效的环境配置文件，请检查 env 目录!');
  process.exit(1);
}

logger.success(`找到 ${modes.length} 个环境配置文件`);

async function run() {
  // 显示应用标题和系统信息
  printAppTitle();
  logger.system();
  logger.divider();

  // 检查系统兼容性
  const compatibilityIssues = checkSystemCompatibility();
  if (compatibilityIssues.length > 0) {
    logger.warning('检测到潜在的系统兼容性问题:');
    compatibilityIssues.forEach((issue) => {
      console.log(colors.yellow(`  - ${issue}`));
    });
    logger.divider();
  }

  logger.info(`正在加载环境配置文件，目录: ${envDir}`);

  // 读取历史选择记录
  const history = readHistory();

  // 使用针对操作系统优化的选项
  const osSpecificChoices = {
    commands: [
      {
        name: `${isWindows ? '🚀' : '🚀'} 运行项目 (serve)`,
        value: 'serve',
      },
      {
        name: `${isWindows ? '📦' : '📦'} 构建项目 (build)`,
        value: 'build',
      },
      {
        name: `${isWindows ? '👁️' : '👁️'} 预览构建结果 (preview)`,
        value: 'preview',
      },
    ],
    envPrefix: isWindows ? '🔧' : '🔧',
    countyPrefix: isWindows ? '🏙️' : '🏙️',
    deployPrefix: isWindows ? '🚢' : '🚢',
  };

  const answers = await inquirer.prompt([
    {
      type: 'list',
      name: 'commandVite',
      message: '请选择指令【command】:',
      suffix: 'env',
      default: history.commandVite || 'serve',
      choices: osSpecificChoices.commands,
      prefix: osSpecificChoices.envPrefix,
    },
    {
      type: 'list',
      name: 'mode',
      message: '请选择环境变量【env】:',
      suffix: 'env',
      default: history.mode || 'development',
      choices: modes.map(mode => ({
        name:
          mode === 'development'
            ? `${mode} (开发环境)`
            : mode === 'production'
              ? `${mode} (生产环境)`
              : mode,
        value: mode,
      })),
      when: answers => answers.commandVite !== 'preview', // 预览模式不需要选择环境变量
      prefix: osSpecificChoices.envPrefix,
    },
  ]);

  // 保存选择历史
  saveHistory(answers);

  try {
    const { mode, commandVite } = answers;

    logger.title('配置信息');
    logger.info(`指令: ${commandVite}`);
    if (commandVite !== 'preview') {
      logger.info(`环境: ${mode}`);
    }
    logger.divider();

    // 定义执行命令的变量
    let execCommand = 'cross-env';
    let execArgs = [];
    let execOptions = {
      stdio: 'inherit',
      shell: true,
      windowsHide: false, // Windows下显示命令窗口
      // 将环境变量传递给子进程
      env: { ...process.env, NODE_NO_WARNINGS: '1', FORCE_COLOR: forceColorLevel.toString() },
    };

    // 根据命令类型选择不同处理方式
    if (commandVite === 'preview') {
      // 预览模式，查找可用的构建产物目录
      const outDirs = [];
      try {
        // 检查.outDir目录是否存在
        const outDirPath = resolve(process.cwd(), '.outDir');
        if (fs.existsSync(outDirPath)) {
          // 读取.outDir目录中的所有子文件夹
          const subDirs = fs.readdirSync(outDirPath).filter((item) => {
            const fullPath = resolve(outDirPath, item);
            return fs.statSync(fullPath).isDirectory();
          });

          // 将子文件夹添加到选项中
          if (subDirs.length > 0) {
            subDirs.forEach((dir) => {
              const fullPath = resolve(outDirPath, dir);
              outDirs.push({
                name: `${buildOutputDir}${buildOutputDir === '.outDir/dist' ? ' (默认)' : ''}`,
                value: resolve(outDirPath, dir),
              });
            });
          }
          else {
            logger.warning('.outDir目录存在但没有子文件夹');
          }
        }
        else {
          logger.warning('.outDir目录不存在');
        }
      }
      catch (e) {
        logger.warning(`查找构建产物目录失败: ${e.message}`);
      }

      // 如果没有找到任何构建产物，提示用户先构建
      if (outDirs.length === 0) {
        logger.error('未找到任何构建产物目录，请先运行构建命令');
        logger.info('您可以运行以下命令构建项目:');
        logger.info(colors.cyan('node scripts/spawn.scripts.js'));
        return;
      }

      // 无论有几个产物目录，都让用户选择
      let targetDir = null;

      logger.info('请选择要预览的SPA构建产物目录:');
      const { selectedDir } = await inquirer.prompt([
        {
          type: 'list',
          name: 'selectedDir',
          message: '请选择要预览的构建产物目录:',
          choices: outDirs,
          default: buildOutputDir,
        },
      ]);
      targetDir = selectedDir;

      logger.info(`将预览静态SPA目录: ${targetDir}`);

      // 预览模式，直接使用serve命令
      logger.info('使用serve命令启动静态文件服务器预览构建结果');

      // 检查serve命令是否存在
      try {
        const checkCommand = isWindows ? 'where' : 'which';
        require('node:child_process').execSync(`${checkCommand} serve`);
      }
      catch (e) {
        logger.warning('没有找到serve命令，将尝试使用npx安装并启动');
      }

      // 使用serve启动静态服务器，添加--single选项支持SPA路由
      execCommand = 'npx';
      execArgs = ['serve', '-s', targetDir, '--single'];

      if (defaultPort) {
        execArgs.push('-l', defaultPort.toString());
      }

      logger.info(`预览命令: ${execCommand} ${execArgs.join(' ')}`);
      logger.info('服务启动后将支持SPA路由，刷新页面时不会404');

      // 更新execOptions，预览不需要环境变量等特殊处理
      execOptions = {
        stdio: 'inherit',
        shell: true,
        windowsHide: false,
      };
    }
    else {
      // 其他命令时的处理
      logger.info(`运行时将加载环境文件: [.env, ${`.env.${mode}`}]`);

      // 适配不同操作系统的Vite路径
      const vitePath = getVitePath();

      // 构建命令参数，添加NODE_NO_WARNINGS环境变量
      const args = ['NODE_NO_WARNINGS=1', vitePath, commandVite, '--mode', mode || 'development'];

      // 为serve命令添加端口和是否打开浏览器参数
      if (commandVite === 'serve') {
        if (defaultPort) {
          args.push('--port', defaultPort.toString());
        }
        if (openBrowser) {
          args.push('--open');
        }

        // 根据环境变量决定是否同时启动文档服务
        if (startDocs) {
          logger.info('开发服务启动时，将同时启动文档服务');

          // 启动开发服务的同时启动文档服务
          setTimeout(() => {
            logger.info('正在启动文档服务...');
            const docsProcess = spawn('npx', ['vitepress', 'dev', 'docs'], {
              stdio: 'inherit',
              shell: true,
            });

            docsProcess.on('error', (error) => {
              logger.error(`文档服务启动失败: ${error.message}`);
            });

            // 当主进程终止时，也终止文档服务进程
            process.on('exit', () => {
              try {
                docsProcess.kill();
              }
              catch (e) {
                logger.debug(`关闭文档服务出错: ${e.message}`);
              }
            });
          }, 5000); // 等待5秒后启动文档服务，确保主服务先启动
        }
      }

      // 为构建命令添加内存限制参数
      if (commandVite === 'build') {
        args.unshift(`--max_old_space_size=${memoryLimit}`);
        // 计算内存限制
        const memoryLimitGB = Math.round(memoryLimit / 1024);
        logger.info(`已设置Node.js内存限制为${memoryLimitGB}GB`);

        // 添加输出目录参数，如果vite支持的话
        if (buildOutputDir) {
          args.push('--outDir', buildOutputDir);
        }

        // 根据环境变量决定是否添加debug选项
        if (enableDebugMode) {
          args.push('--debug');
          logger.info('已启用debug模式，将显示更详细的错误信息');
        }
      }

      // 尝试查找本地安装的cross-env
      const localCrossEnvPath = normalizePath('./node_modules/.bin/cross-env');
      const hasLocalCrossEnv = fs.existsSync(
        resolve(
          process.cwd(),
          isWindows ? localCrossEnvPath.replace(/\//g, '\\') : localCrossEnvPath,
        ),
      );

      // 设置执行命令和参数
      execCommand = 'cross-env';
      execArgs = args.filter(e => e);

      // 如果在Windows上且找到了本地安装的cross-env，直接使用其路径
      if (isWindows && hasLocalCrossEnv) {
        execCommand = normalizePath(localCrossEnvPath);
        logger.info(`使用本地安装的cross-env: ${execCommand}`);
      }

      // 如果运行在Windows环境
      if (isWindows) {
        logger.info(`Windows环境: 使用${hasLocalCrossEnv ? '本地' : '全局'}cross-env`);
        // Windows下可能需要使用cmd /c 前缀确保命令正确执行
        if (!hasLocalCrossEnv) {
          execCommand = 'cmd';
          execArgs = ['/c', 'cross-env', ...execArgs];
          logger.info(`实际执行命令: ${execCommand} ${execArgs.join(' ')}`);
        }
      }
      else if (isMac) {
        logger.info(`macOS环境: 使用${hasLocalCrossEnv ? '本地' : '全局'}cross-env`);
      }
    }

    logger.title('正在执行命令');
    logger.info(`${execCommand} ${execArgs.filter(e => e).join(' ')}`);
    logger.divider();

    // 使用进度指示器提示命令执行
    const spinner = createSpinner(
      `正在${
        commandVite === 'serve'
          ? '启动开发服务器'
          : commandVite === 'build'
            ? '构建项目'
            : '启动预览服务器'
      }`,
    ).start();

    // 修改execOptions，捕获stdout和stderr
    execOptions.stdio = ['inherit', 'pipe', 'pipe']; // 捕获标准输出和错误输出

    const viteProcess = spawn(execCommand, execArgs, execOptions);

    // 监听标准输出
    viteProcess.stdout.on('data', (data) => {
      const output = data.toString();

      // 只在关键时刻更新spinner状态
      if (commandVite === 'build') {
        // 检测构建开始
        if (output.includes('building for')) {
          spinner.text('构建中: 准备环境...');
        }
        // 检测转换阶段
        else if (output.includes('transforming')) {
          spinner.text('构建中: 转换文件...');
        }
        // 检测模块转换完成
        else if (output.match(/\d+\s+modules transformed/)) {
          const moduleMatch = output.match(/(\d+)\s+modules transformed/);
          const moduleCount = moduleMatch ? moduleMatch[1] : '';
          spinner.text(`构建中: 已转换${moduleCount}个模块`);
        }
        // 检测渲染chunks阶段
        else if (output.includes('rendering chunks')) {
          spinner.text('构建中: 渲染代码块...');
        }
        // 检测配置文件构建完成
        else if (output.includes('configuration file is build successfully')) {
          spinner.text('构建中: 配置文件已构建');
        }
        // 检测构建完成
        else if (output.includes('built in')) {
          const timeMatch = output.match(/built in (\d+(?:\.\d*)?)(s|ms)/);
          const buildTime = timeMatch ? `${timeMatch[1]}${timeMatch[2]}` : '完成';
          spinner.succeed(`构建已完成! 用时: ${buildTime}`);
        }
      }
      // 服务器启动成功
      else if (
        commandVite === 'serve'
        && (output.includes('Local:') || output.includes('ready in'))
      ) {
        spinner.succeed('开发服务器已成功启动!');
      }
      // 预览服务器启动成功
      else if (commandVite === 'preview') {
        // serve命令启动成功
        if (output.includes('Serving!') || output.includes('Available on')) {
          spinner.succeed('预览服务器已成功启动!');

          // 提取serve输出的URL地址
          const urlMatch = output.match(/(http:\/\/\S+)/);
          if (urlMatch && urlMatch[1]) {
            logger.success(`预览地址: ${urlMatch[1]}`);
          }
        }
      }

      // 始终输出原始日志
      process.stdout.write(data);
    });

    // 监听错误输出
    viteProcess.stderr.on('data', (data) => {
      const errorOutput = data.toString();

      // 始终显示构建错误，不管配置如何
      if (commandVite === 'build') {
        // 直接输出所有构建过程的错误和警告
        process.stderr.write(data);
      }
      else {
        // 非构建命令的处理逻辑保持不变
        // 根据配置决定是否在构建时显示警告
        const shouldHideWarning = !showBuildWarnings;

        // 如果应该隐藏警告，直接返回
        if (shouldHideWarning && !errorOutput.includes('ERROR')) {
          return;
        }
        // 对于错误，先停止spinner避免干扰错误显示
        if (errorOutput.includes('ERROR')) {
          spinner.stop();
          process.stderr.write(data);
          spinner.fail('执行过程中出现错误');
        }
        else {
          // 输出原始错误消息
          process.stderr.write(data);
        }
      }
    });

    // 启动资源监控（仅在构建模式下）
    let stopMonitoring = null;
    if (commandVite === 'build') {
      stopMonitoring = monitorResources(viteProcess, {
        interval: Number.parseInt(baseEnvVars.VITE_MONITOR_INTERVAL) || 3000, // 每3秒更新一次
        threshold: Number.parseInt(baseEnvVars.VITE_MONITOR_CPU_THRESHOLD) || 85, // 从环境变量获取CPU阈值
      });
    }

    viteProcess.on('error', (error) => {
      spinner.fail(`执行错误: ${error.message}`);
      logger.error(`执行错误: ${error.message}`);

      if (isWindows && error.message.includes('ENOENT')) {
        logger.error('找不到cross-env命令，请确保已正确安装');
        logger.warning('您可以尝试以下解决方案:');
        logger.warning('1. 全局安装: npm install -g cross-env');
        logger.warning('2. 检查项目依赖: npm install');
        logger.warning(
          `3. 直接运行: node ./node_modules/vite/bin/vite.js ${args.slice(1).join(' ')}`,
        );
      }

      // 只在build命令时停止资源监控
      if (commandVite === 'build' && stopMonitoring) {
        stopMonitoring();
      }
    });

    viteProcess.on('exit', async (code) => {
      // 只在build命令时停止资源监控
      if (commandVite === 'build' && stopMonitoring) {
        stopMonitoring();
      }

      if (code === 0) {
        spinner.succeed(
          `${
            commandVite === 'serve'
              ? '开发服务器'
              : commandVite === 'build'
                ? '构建过程'
                : '预览服务器'
          }已成功启动!`,
        );
        // 如果是构建命令，显示输出目录信息
        if (commandVite === 'build') {
          logger.success(`构建输出目录: ${buildOutputDir}`);
          logger.success(`构建产物是纯静态SPA应用，您可以部署到任何静态Web服务器上。`);
          logger.success(`您可以用以下命令启动静态文件服务器来预览:\n`);
          if (isWindows) {
            logger.success(colors.cyan(`npx serve -s ${normalizePath(buildOutputDir)} --single`));
            logger.success(
              colors.cyan(`npx http-server ${normalizePath(buildOutputDir)} -p 8080 --spa`),
            );
          }
          else {
            logger.success(colors.cyan(`npx serve -s ${buildOutputDir} --single`));
            logger.success(colors.cyan(`npx http-server ${buildOutputDir} -p 8080 --spa`));
          }

          // 如果配置了自动打开构建目录，则执行相应命令
          if (openOutDir) {
            try {
              logger.info('正在打开构建产物目录...');
              const openCommand = isWindows
                ? `explorer ${normalizePath(resolve(process.cwd(), buildOutputDir))}`
                : isMac
                  ? `open ${resolve(process.cwd(), buildOutputDir)}`
                  : `xdg-open ${resolve(process.cwd(), buildOutputDir)}`;

              // 使用子进程打开目录
              require('node:child_process').exec(openCommand, (error) => {
                if (error) {
                  logger.warning(`无法自动打开目录: ${error.message}`);
                }
              });
            }
            catch (err) {
              logger.warning(`打开目录失败: ${err.message}`);
            }
          }
        }
      }
      else {
        // 对于serve命令，退出码1通常是用户手动中断，不应该视为错误
        if (['serve', 'preview'].includes(commandVite) && code === 1) {
          spinner.info(`${commandVite === 'serve' ? '开发服务器' : '预览服务器'}已终止`);
          logger.info(
            `${commandVite === 'serve' ? '开发服务器' : '预览服务器'}已终止，退出码: ${code}`,
          );
          logger.info(`这可能是由于用户手动中断服务器（Ctrl+C）或重启服务器导致的，属于正常现象。`);
        }
        else {
          spinner.fail(`进程退出，退出码: ${code}`);
          logger.error(`进程退出，退出码: ${code}`);

          // 输出更详细的错误信息和日志位置
          logger.divider();
          logger.error(`构建过程中出现错误，请检查上方日志中的错误信息`);

          // 添加更多的构建故障排查信息
          if (commandVite === 'build') {
            logger.error(`构建失败可能原因分析:`);
            logger.warning(`1. 代码问题:`);
            logger.warning(`   - TypeScript类型错误: 尝试运行 npx tsc --noEmit 检查类型问题`);
            logger.warning(`   - 代码语法错误: 检查最近修改的文件`);
            logger.warning(`   - 导入路径错误: 检查import语句是否正确`);

            logger.warning(`2. 构建配置问题:`);
            logger.warning(`   - Vite配置冲突: 查看vite.config.ts文件`);
            logger.warning(`   - 插件冲突: 尝试暂时禁用部分插件`);

            logger.warning(`3. 环境问题:`);
            logger.warning(`   - 环境变量问题: 检查.env.${process.env.MODE || 'production'}文件`);
            logger.warning(`   - 临时文件问题: 尝试删除.vite和node_modules/.vite缓存目录`);

            logger.warning(`4. 构建调试方法:`);
            logger.warning(`   - 启用debug模式: 在.env文件中添加 VITE_BUILD_DEBUG_MODE=true`);
            logger.warning(`   - 检查是否有Sourcemap信息指向错误位置`);
          }

          logger.divider();
        }
      }
    });
  }
  catch (error) {
    logger.error(`执行过程中发生错误: ${error.message}`);
    if (error.stack) {
      logger.divider();
      console.error(error.stack);
    }
  }
}

// 捕获全局异常
process.on('uncaughtException', (error) => {
  logger.error(`未捕获的异常: ${error.message}`);
  console.error(error.stack);
  process.exit(1);
});

// 启动时展示兼容性信息和系统支持
run()
  .then(() => {
    logger.divider();
  })
  .catch((error) => {
    logger.error(`执行过程中发生致命错误: ${error.message}`);
    logger.info(`请将错误信息反馈给开发团队进行修复。`);
    process.exit(1);
  });
